const express = require('express');
const path = require('path');
const fs = require('fs-extra');
const config = require('../config/server');

const router = express.Router();

// 递归获取目录下的所有文件
async function getAllFiles(dirPath, basePath = '') {
    const files = [];
    const items = await fs.readdir(dirPath);
    
    for (const item of items) {
        const fullPath = path.join(dirPath, item);
        const relativePath = path.join(basePath, item).replace(/\\/g, '/');
        const stat = await fs.stat(fullPath);
        
        if (stat.isDirectory()) {
            // 递归获取子目录文件
            const subFiles = await getAllFiles(fullPath, relativePath);
            files.push(...subFiles);
        } else {
            // 添加文件
            files.push({
                path: relativePath,
                size: stat.size,
                modified: stat.mtime
            });
        }
    }
    
    return files;
}

// 获取目录文件列表API
router.get('/api/directory/:dirName', async (req, res) => {
    try {
        const { dirName } = req.params;
        const dirPath = path.join(config.staticPath, 'html', dirName);
        
        // 检查目录是否存在
        if (!await fs.pathExists(dirPath)) {
            return res.status(404).json({ error: '目录不存在' });
        }
        
        // 检查是否为目录
        const stat = await fs.stat(dirPath);
        if (!stat.isDirectory()) {
            return res.status(400).json({ error: '路径不是目录' });
        }
        
        // 获取目录下的所有文件
        const files = await getAllFiles(dirPath);
        
        res.json({
            directory: dirName,
            files: files,
            count: files.length
        });
        
    } catch (error) {
        console.error('获取目录文件列表错误:', error);
        res.status(500).json({ error: '服务器内部错误' });
    }
});

// 静态资源服务
router.get('*', async (req, res, next) => {
    try {
        const requestedPath = req.params[0] || '';
        
        // 安全检查：防止目录遍历攻击
        if (requestedPath.includes('..') || requestedPath.includes('~')) {
            return res.status(400).json({
                error: '无效的路径',
                path: requestedPath
            });
        }
        
        // 将 /static/ 路径映射到 /html/ 路径
        // 由于路由是 '/*'，requestedPath 已经去掉了 /static 前缀
        // 所以直接添加 html/ 前缀
        const mappedPath = 'html/' + requestedPath;
        
        // 构建完整文件路径
        const fullPath = path.join(config.staticPath, mappedPath);
        
        // 检查文件是否存在
        const stats = await fs.stat(fullPath);
        
        if (stats.isDirectory()) {
            // 如果是目录，尝试查找index.html
            const indexPath = path.join(fullPath, 'index.html');
            if (await fs.pathExists(indexPath)) {
                return res.sendFile(indexPath);
            } else {
                return res.status(404).json({
                    error: '目录不存在或没有默认文件',
                    path: requestedPath
                });
            }
        }
        
        if (stats.isFile()) {
            // 设置正确的Content-Type
            const ext = path.extname(fullPath).toLowerCase();
            const mimeTypes = {
                '.html': 'text/html; charset=utf-8',
                '.htm': 'text/html; charset=utf-8',
                '.css': 'text/css; charset=utf-8',
                '.js': 'application/javascript; charset=utf-8',
                '.json': 'application/json; charset=utf-8',
                '.png': 'image/png',
                '.jpg': 'image/jpeg',
                '.jpeg': 'image/jpeg',
                '.gif': 'image/gif',
                '.svg': 'image/svg+xml',
                '.ico': 'image/x-icon',
                '.woff': 'font/woff',
                '.woff2': 'font/woff2',
                '.ttf': 'font/ttf',
                '.eot': 'application/vnd.ms-fontobject'
            };
            
            const contentType = mimeTypes[ext] || 'application/octet-stream';
            res.set('Content-Type', contentType);
            
            // 发送文件
            return res.sendFile(fullPath);
        }
        
        // 既不是文件也不是目录
        return res.status(404).json({
            error: '资源未找到',
            path: requestedPath
        });
        
    } catch (error) {
        if (error.code === 'ENOENT') {
            return res.status(404).json({
                error: '资源未找到',
                path: req.params[0]
            });
        }
        
        console.error('静态资源服务错误:', error);
        next(error);
    }
});

module.exports = router;
